/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package vigas.calculos;

import java.util.List;
import vigas.componentes.Apoio;
import vigas.componentes.CargaAplicada;
import vigas.componentes.CargaDistribuida;
import vigas.componentes.Engaste;
import vigas.componentes.Momento;
import vigas.componentes.Viga;
import vigas.gui.PainelDeDesenho;
import vigas.util.Constantes;

/**
 *
 * @author João
 */
public class Calculo {

    private int numeroApoios, numeroEngastes;
    public double v[], m[];
    int posicaoSegundoApoio=-1;


    private void calculaApoios(List<Apoio> apoios){
        
        numeroApoios=0; numeroEngastes=0;
        
        for(Apoio a: apoios)
            if(a instanceof Engaste)
                numeroEngastes++;
            else
                numeroApoios++;
        
    }


    private boolean apoiosEstaoNasExtremidades(List<Apoio> apoios, Viga v){

            for(Apoio a: apoios)
                if(a.getPontoMarcadoNaviga().x > v.getInicio() && a.getPontoMarcadoNaviga().x < v.getFim()){
                    posicaoSegundoApoio = a.getPontoMarcadoNaviga().x;
                    return false;
                }
        return true;
    }

    public void efetuar(PainelDeDesenho painelDeDesenho){



        Viga v = painelDeDesenho.getViga();
        int L = v.getQtdDePontos(); //fazer conversão para centímetros
        List<Apoio> apoios = painelDeDesenho.getApoios();

        this.v = new double[L];
        this.m = new double[L];
        zerarVetor(this.m);
        zerarVetor(this.v);

        //System.out.println("numero do vetor " + this.v[0]);

        calculaApoios(apoios);

        
        System.out.println("comprimento da viga: " + L);
        System.out.println("viga: inicio " + v.getInicio() + " fim " + v.getFim()  );

        CargaAplicada cargaAplicada = painelDeDesenho.getCargaAplicada();
        CargaDistribuida cargaDistribuida = painelDeDesenho.getCargaDistribuida();
        Momento momento = painelDeDesenho.getMomento();

        //System.out.println("posicao relativa x: " + cargaAplicada.getPosicaoRelativa(v));

        //duplo apoio
        if(numeroApoios == 2 && apoiosEstaoNasExtremidades(apoios, v)){
            VigaDuploApoio vigaDuploApoio = new VigaDuploApoio(0, 2, L, v.getQtdDePontos());
            acrescentaCargaConcentrada(cargaAplicada, vigaDuploApoio, v);
            acrescentaCargaDistribuida(cargaDistribuida, vigaDuploApoio, v);
            acrescentaMomento(momento, vigaDuploApoio, v);
        }

        //em balanço
        if(numeroApoios==0 && numeroEngastes==1){
            VigaEmBalanco vigaEmBalanco = new VigaEmBalanco(0, 2, L, v.getQtdDePontos());
            acrescentaCargaConcentrada(cargaAplicada, vigaEmBalanco, v);
            acrescentaCargaDistribuida(cargaDistribuida, vigaEmBalanco, v);
            acrescentaMomento(momento, vigaEmBalanco, v);
        }

        //duplo apoio com apoio móvel
        if(numeroApoios == 2 && !apoiosEstaoNasExtremidades(apoios, v)){
            VigaBalancoExtremidade vigaBalancoExtremidade = new VigaBalancoExtremidade(0, 2, L, v.getQtdDePontos());
            vigaBalancoExtremidade.setPosicaoSegundoApoio(posicaoSegundoApoio);
            acrescentaCargaConcentrada(cargaAplicada, vigaBalancoExtremidade, v);
            acrescentaCargaDistribuida(cargaDistribuida, vigaBalancoExtremidade, v);
            acrescentaMomento(momento, vigaBalancoExtremidade, v);
        }

    }

    private void acrescentaCargaConcentrada( CargaAplicada cargaAplicada, DiagramaEsforco d, Viga v){

        if(cargaAplicada != null){
            float x = cargaAplicada.getPosicaoRelativa(v);
            System.out.println("posicao relativa da carga aplicada " + x);
            d.calcularEsforcosCargaConcentrada(cargaAplicada.getValorDaCarga(), x);
            adicionaVetores(this.v, d.getV());
            adicionaVetores(m, d.getM());
        }
    }

    private void acrescentaCargaDistribuida(CargaDistribuida c, DiagramaEsforco d, Viga v){

        if(c != null){
            d.calcularEsforcosCargaDistribuida(c.getValorDaCarga(), c.getValorDaCarga(),
                                               c.getInicioRelativo(v),
                                               c.getFimRelativo(v));
            adicionaVetores(this.v, d.getV());
            adicionaVetores(this.m, d.getM());
        }
    }

    private void acrescentaMomento(Momento m, DiagramaEsforco d, Viga v){
        if(m!=null)
            d.calcularEsforcosMomentoConcentrado(m.getValorDoMomento(), m.getPosicaoRelativa(v));
            adicionaVetores(this.v, d.getV());
            adicionaVetores(this.m, d.getM());
    }

    public boolean podeGerarGraficos(){
        if (m != null && v !=null){
            if(m.length > 0 && v.length > 0)
                return true;
            return false;
        }
            return false;
    }

    private void adicionaVetores(double v1[], double v2[]){
        for(int i=0; i < v1.length; i++)
            v1[i] += v2[i];
    }

    private void zerarVetor(double v1[]){
        for(int i=0; i < v1.length; i++)
            v1[i] =0;
    }
}
